Statistics: Rename sparse_zeros to sparse_implicit_zeros

Author: pavlin-policar

Orange/data/table.py

@@ -19,8 +19,8 @@
 )
 from Orange.data.util import SharedComputeValue, vstack, hstack
 from Orange.statistics.util import bincount, countnans, contingency, \
-    stats as fast_stats, sparse_has_zeros, sparse_count_zeros, \
-    sparse_zero_weights
+    stats as fast_stats, sparse_has_implicit_zeros, sparse_count_implicit_zeros, \
+    sparse_implicit_zero_weights
 from Orange.util import flatten
 
 __all__ = ["dataset_dirs", "get_sample_datasets_dir", "RowInstance", "Table"]
@@ -1427,11 +1427,11 @@ def _compute_distributions(self, columns=None):
                 dist = np.array(_valuecount.valuecount(vals))
                 # If sparse, then 0s will not be counted with `valuecount`, so
                 # we have to add them to the result manually.
-                if sp.issparse(x) and sparse_has_zeros(x):
+                if sp.issparse(x) and sparse_has_implicit_zeros(x):
                     if W is not None:
-                        zero_weights = sparse_zero_weights(x, W).sum()
+                        zero_weights = sparse_implicit_zero_weights(x, W).sum()
                     else:
-                        zero_weights = sparse_count_zeros(x)
+                        zero_weights = sparse_count_implicit_zeros(x)
                     zero_vec = [0, zero_weights]
                     dist = np.insert(dist, np.searchsorted(dist[0], 0), zero_vec, axis=1)
                 # Since `countnans` assumes vector shape to be (1, n) and `x`

Orange/statistics/util.py

@@ -30,21 +30,21 @@ def _count_nans_per_row_sparse(X, weights, dtype=None):
     return np.fromiter((np.isnan(row.data).sum() for row in X), dtype=dtype)
 
 
-def sparse_count_zeros(x):
+def sparse_count_implicit_zeros(x):
     """ Count the number of implicit zeros in a sparse matrix. """
     if not sp.issparse(x):
         raise TypeError('The matrix provided was not sparse.')
     return np.prod(x.shape) - x.nnz
 
 
-def sparse_has_zeros(x):
+def sparse_has_implicit_zeros(x):
     """ Check if sparse matrix contains any implicit zeros. """
     if not sp.issparse(x):
         raise TypeError('The matrix provided was not sparse.')
     return np.prod(x.shape) != x.nnz
 
 
-def sparse_zero_weights(x, weights):
+def sparse_implicit_zero_weights(x, weights):
     """ Extract the weight values of all zeros in a sparse matrix. """
     if not sp.issparse(x):
         raise TypeError('The matrix provided was not sparse.')
@@ -103,10 +103,10 @@ def bincount(x, weights=None, max_val=None, minlength=None):
     if sp.issparse(x):
         x = x.tocsr()
         if weights is not None:
-            zero_weights = sparse_zero_weights(x, weights).sum()
+            zero_weights = sparse_implicit_zero_weights(x, weights).sum()
             weights = weights[x.indices]
         else:
-            zero_weights = sparse_count_zeros(x)
+            zero_weights = sparse_count_implicit_zeros(x)
 
         x = x.data
 
@@ -343,7 +343,7 @@ def _nan_min_max(x, func, axis=0):
         return func(x, axis=axis)
     if axis is None:
         extreme = func(x.data, axis=axis) if x.nnz else float('nan')
-        if sparse_has_zeros(x):
+        if sparse_has_implicit_zeros(x):
             extreme = func([0, extreme])
         return extreme
     if axis == 0:
@@ -356,7 +356,7 @@ def _nan_min_max(x, func, axis=0):
     for row in x:
         values = row.data
         extreme = func(values) if values.size else float('nan')
-        if sparse_has_zeros(row):
+        if sparse_has_implicit_zeros(row):
             extreme = func([0, extreme])
         r.append(extreme)
     return np.array(r)
@@ -422,7 +422,7 @@ def unique(x, return_counts=False):
     if not sp.issparse(x):
         return np.unique(x, return_counts=return_counts)
 
-    implicit_zeros = sparse_count_zeros(x)
+    implicit_zeros = sparse_count_implicit_zeros(x)
     explicit_zeros = not np.all(x.data)
     r = np.unique(x.data, return_counts=return_counts)
     if not implicit_zeros: