Converted all dtypes to np.float64/np.int64

Author: seanlaw

stumpy/aamp.py

@@ -182,8 +182,8 @@ def _aamp(T_A, T_B, m, T_A_subseq_isfinite, T_B_subseq_isfinite, diags, ignore_t
     n_B = T_B.shape[0]
     l = n_A - m + 1
     n_threads = numba.config.NUMBA_NUM_THREADS
-    P = np.full((n_threads, l, 3), np.inf)
-    I = np.full((n_threads, l, 3), -1, np.int64)
+    P = np.full((n_threads, l, 3), np.inf, dtype=np.float64)
+    I = np.full((n_threads, l, 3), -1, dtype=np.int64)
 
     ndist_counts = core._count_diagonal_ndist(diags, m, n_A, n_B)
     diags_ranges = core._get_array_ranges(ndist_counts, n_threads, False)

stumpy/aamp_motifs.py

@@ -124,10 +124,10 @@ def _aamp_motifs(
         candidate_idx = np.argmin(P[-1])
 
     motif_distances = core._jagged_list_to_array(
-        motif_distances, fill_value=np.nan, dtype="float64"
+        motif_distances, fill_value=np.nan, dtype=np.float64
     )
     motif_indices = core._jagged_list_to_array(
-        motif_indices, fill_value=-1, dtype="int64"
+        motif_indices, fill_value=-1, dtype=np.int64
     )
 
     return motif_distances, motif_indices

stumpy/aamp_ostinato.py

@@ -54,7 +54,7 @@ def _aamp_across_series_nearest_neighbors(
 
     for i in range(k):
         if np.any(~np.isfinite(Q)):  # pragma: no cover
-            distance_profile = np.empty(Ts[i].shape[0] - m + 1)
+            distance_profile = np.empty(Ts[i].shape[0] - m + 1, dtype=np.float64)
             distance_profile[:] = np.inf
         else:
             QT = core.sliding_dot_product(

stumpy/aampdist_snippets.py

@@ -86,7 +86,7 @@ def _get_all_aampdist_profiles(
         T = np.pad(T, pad_width, mode="constant", constant_values=np.nan)
 
     n_padded = T.shape[0]
-    D = np.empty(((n_padded // m) - 1, n_padded - m + 1))
+    D = np.empty(((n_padded // m) - 1, n_padded - m + 1), dtype=np.float64)
 
     if s is not None:
         s = min(int(s), m)
@@ -214,11 +214,11 @@ def aampdist_snippets(
 
     snippets = np.empty((k, m))
     snippets_indices = np.empty(k, dtype=np.int64)
-    snippets_profiles = np.empty((k, D.shape[-1]))
-    snippets_fractions = np.empty(k)
-    snippets_areas = np.empty(k)
-    Q = np.full(D.shape[-1], np.inf)
-    indices = np.arange(0, n_padded - m, m)
+    snippets_profiles = np.empty((k, D.shape[-1]), dtype=np.float64)
+    snippets_fractions = np.empty(k, dtype=np.float64)
+    snippets_areas = np.empty(k, dtype=np.float64)
+    Q = np.full(D.shape[-1], np.inf, dtype=np.float64)
+    indices = np.arange(0, n_padded - m, m, dtype=np.int64)
     snippets_regimes_list = []
 
     for i in range(k):

stumpy/aamped.py

@@ -113,7 +113,7 @@ def aamped(dask_client, T_A, m, T_B=None, ignore_trivial=True):
     diags_futures = []
     for i, host in enumerate(hosts):
         diags_future = dask_client.scatter(
-            np.arange(diags_ranges[i, 0], diags_ranges[i, 1]),
+            np.arange(diags_ranges[i, 0], diags_ranges[i, 1], dtype=np.int64),
             workers=[host],
             hash=False,
         )

stumpy/aampi.py

@@ -88,7 +88,7 @@ def __init__(self, T, m, egress=True):
         self._P = mp[:, 0].astype(np.float64)
         self._I = mp[:, 1].astype(np.int64)
         self._left_I = mp[:, 2].astype(np.int64)
-        self._left_P = np.empty(self._P.shape)
+        self._left_P = np.empty(self._P.shape, dtype=np.float64)
         self._left_P[:] = np.inf
 
         self._T_isfinite = np.isfinite(self._T)
@@ -110,7 +110,7 @@ def __init__(self, T, m, egress=True):
         Q = self._T[-m:]
         self._QT = core.sliding_dot_product(Q, self._T)
         if self._egress:
-            self._QT_new = np.empty(self._QT.shape[0])
+            self._QT_new = np.empty(self._QT.shape[0], dtype=np.float64)
             self._n_appended = 0
 
     def update(self, t):
@@ -208,7 +208,7 @@ def _update(self, t):
         self._n = self._T.shape[0]
         l = self._n - self._m + 1
         T_new = np.append(self._T, t)
-        QT_new = np.empty(self._QT.shape[0] + 1)
+        QT_new = np.empty(self._QT.shape[0] + 1, dtype=np.float64)
         S = T_new[l:]
         t_drop = T_new[l - 1]
 

stumpy/core.py

@@ -927,7 +927,7 @@ def _calculate_squared_distance_profile(m, QT, μ_Q, σ_Q, M_T, Σ_T):
     See Equation on Page 4
     """
     k = M_T.shape[0]
-    D_squared = np.empty(k)
+    D_squared = np.empty(k, dtype=np.float64)
 
     for i in prange(k):
         D_squared[i] = _calculate_squared_distance(m, QT[i], μ_Q, σ_Q, M_T[i], Σ_T[i])
@@ -1069,7 +1069,7 @@ def mass_absolute(Q, T, T_subseq_isfinite=None, T_squared=None):
             f"the length of `T` ({len(T)}). "
         )
 
-    distance_profile = np.empty(n - m + 1)
+    distance_profile = np.empty(n - m + 1, dtype=np.float64)
     if np.any(~np.isfinite(Q)):
         distance_profile[:] = np.inf
     else:
@@ -1159,11 +1159,11 @@ def mueen_calculate_distance_profile(Q, T):
     Q_norm = (Q - μ_Q) / σ_Q
     QT = sliding_dot_product(Q_norm, T)
 
-    cumsum_T = np.empty(len(T) + 1)  # Add one element, fix off-by-one
+    cumsum_T = np.empty(len(T) + 1, dtype=np.float64)  # Add one element, fix off-by-one
     np.cumsum(T, out=cumsum_T[1:])  # store output in cumsum_T[1:]
     cumsum_T[0] = 0
 
-    cumsum_T_squared = np.empty(len(T) + 1)
+    cumsum_T_squared = np.empty(len(T) + 1, dtype=np.float64)
     np.cumsum(np.square(T), out=cumsum_T_squared[1:])
     cumsum_T_squared[0] = 0
 
@@ -1320,7 +1320,7 @@ def mass(Q, T, M_T=None, Σ_T=None, normalize=True):
             f"the length of `T` ({len(T)}). "
         )
 
-    distance_profile = np.empty(n - m + 1)
+    distance_profile = np.empty(n - m + 1, dtype=np.float64)
     if np.any(~np.isfinite(Q)):
         distance_profile[:] = np.inf
     else:
@@ -1668,7 +1668,7 @@ def _get_array_ranges(a, n_chunks, truncate):
         pair. The first column contains the start indices and the second column
         contains the stop indices.
     """
-    array_ranges = np.zeros((n_chunks, 2), np.int64)
+    array_ranges = np.zeros((n_chunks, 2), dtype=np.int64)
     if a.shape[0] > 0 and n_chunks > 0:
         cumsum = a.cumsum() / a.sum()
         insert = np.linspace(0, 1, n_chunks + 1)[1:-1]

stumpy/floss.py

@@ -39,7 +39,7 @@ def _nnmark(I):
     I[idx] = idx
 
     k = I.shape[0]
-    i = np.arange(k)
+    i = np.arange(k, dtype=np.int64)
 
     nnmark = np.bincount(np.minimum(i, I), minlength=k)
     nnmark -= np.bincount(np.maximum(i, I), minlength=k)
@@ -86,15 +86,15 @@ def _iac(
     """
     np.random.seed(seed)
 
-    I = np.random.randint(0, width, size=width)
+    I = np.random.randint(0, width, size=width, dtype=np.int64)
     if bidirectional is False:  # Idealized 1-dimensional matrix profile index
         I[:-1] = width
         for i in range(width - 1):
-            I[i] = np.random.randint(i + 1, width)
+            I[i] = np.random.randint(i + 1, width, dtype=np.int64)
 
     target_AC = _nnmark(I)
 
-    params = np.empty((n_iter, 2))
+    params = np.empty((n_iter, 2), dtype=np.float64)
     for i in range(n_iter):
         hist_dist = scipy.stats.rv_histogram(
             (target_AC, np.append(np.arange(width), width))
@@ -164,7 +164,7 @@ def _cac(I, L, bidirectional=True, excl_factor=5, custom_iac=None, seed=0):
     """
     k = I.shape[0]
     AC = _nnmark(I)
-    CAC = np.zeros(k)
+    CAC = np.zeros(k, dtype=np.float64)
 
     if custom_iac is None:
         IAC = _iac(k, bidirectional, seed=seed)
@@ -218,7 +218,7 @@ def _rea(cac, n_regimes, L, excl_factor=5):
 
     This is the implementation for the regime extracting algorithm (REA).
     """
-    regime_locs = np.empty(n_regimes - 1, dtype=np.int)
+    regime_locs = np.empty(n_regimes - 1, dtype=np.int64)
     tmp_cac = copy.deepcopy(cac)
     for i in range(n_regimes - 1):
         regime_locs[i] = np.argmin(tmp_cac)
@@ -483,7 +483,7 @@ def __init__(
                 n_samples=self._n_samples,
             )
 
-        right_nn = np.zeros((self._k, self._m))
+        right_nn = np.zeros((self._k, self._m), dtype=np.float64)
 
         # Disable the bidirectional matrix profile indices and left indices
         self._mp[:, 1] = -1
@@ -492,7 +492,10 @@ def __init__(
         # Update matrix profile distance to be right mp distance and not bidirectional.
         # Use right indices to perform direct distance calculations
         # Note that any -1 indices must have a np.inf matrix profile value
-        right_indices = [np.arange(IR, IR + self._m) for IR in self._mp[:, 3].tolist()]
+        right_indices = [
+            np.arange(IR, IR + self._m, dtype=np.int64)
+            for IR in self._mp[:, 3].tolist()
+        ]
         right_nn[:] = self._T[np.array(right_indices)]
         if self._normalize:
             self._mp[:, 0] = np.linalg.norm(
@@ -509,7 +512,7 @@ def __init__(
         self._mp[inf_indices, 0] = np.inf
         self._mp[inf_indices, 3] = inf_indices
 
-        self._cac = np.ones(self._k) * -1
+        self._cac = np.ones(self._k, dtype=np.float64) * -1
 
     def update(self, t):
         """

stumpy/gpu_aamp.py

@@ -300,8 +300,8 @@ def _gpu_aamp(
             device_T_B_subseq_isfinite = cuda.to_device(T_B_subseq_isfinite)
             device_T_B_subseq_squared = cuda.to_device(T_B_subseq_squared)
 
-        profile = np.full((k, 3), np.inf)  # float64
-        indices = np.full((k, 3), -1, dtype=np.int64)  # int64
+        profile = np.full((k, 3), np.inf, dtype=np.float64)
+        indices = np.full((k, 3), -1, dtype=np.int64)
 
         device_profile = cuda.to_device(profile)
         device_indices = cuda.to_device(indices)

stumpy/gpu_stump.py

@@ -316,8 +316,8 @@ def _gpu_stump(
             device_M_T = cuda.to_device(M_T)
             device_Σ_T = cuda.to_device(Σ_T)
 
-        profile = np.full((k, 3), np.inf)  # float64
-        indices = np.full((k, 3), -1, dtype=np.int64)  # int64
+        profile = np.full((k, 3), np.inf, dtype=np.float64)
+        indices = np.full((k, 3), -1, dtype=np.int64)
 
         device_profile = cuda.to_device(profile)
         device_indices = cuda.to_device(indices)