Merge pull request scipy#21880 from j-bowhay/cwtspec7

Author: mdhaber

scipy/linalg/_sketches.py

@@ -5,13 +5,14 @@
 
 import numpy as np
 
-from scipy._lib._util import check_random_state, rng_integers
+from scipy._lib._util import (check_random_state, rng_integers,
+                              _transition_to_rng)
 from scipy.sparse import csc_matrix
 
 __all__ = ['clarkson_woodruff_transform']
 
 
-def cwt_matrix(n_rows, n_columns, seed=None):
+def cwt_matrix(n_rows, n_columns, rng=None):
     r"""
     Generate a matrix S which represents a Clarkson-Woodruff transform.
 
@@ -26,13 +27,12 @@ def cwt_matrix(n_rows, n_columns, seed=None):
         Number of rows of S
     n_columns : int
         Number of columns of S
-    seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional
-        If `seed` is None (or `np.random`), the `numpy.random.RandomState`
-        singleton is used.
-        If `seed` is an int, a new ``RandomState`` instance is used,
-        seeded with `seed`.
-        If `seed` is already a ``Generator`` or ``RandomState`` instance then
-        that instance is used.
+    rng : `numpy.random.Generator`, optional
+        Pseudorandom number generator state. When `rng` is None, a new
+        `numpy.random.Generator` is created using entropy from the
+        operating system. Types other than `numpy.random.Generator` are
+        passed to `numpy.random.default_rng` to instantiate a ``Generator``.
+
 
     Returns
     -------
@@ -45,15 +45,16 @@ def cwt_matrix(n_rows, n_columns, seed=None):
     .. math:: \|SA\| = (1 \pm \epsilon)\|A\|
     Where the error epsilon is related to the size of S.
     """
-    rng = check_random_state(seed)
+    rng = check_random_state(rng)
     rows = rng_integers(rng, 0, n_rows, n_columns)
     cols = np.arange(n_columns+1)
     signs = rng.choice([1, -1], n_columns)
-    S = csc_matrix((signs, rows, cols),shape=(n_rows, n_columns))
+    S = csc_matrix((signs, rows, cols), shape=(n_rows, n_columns))
     return S
 
 
-def clarkson_woodruff_transform(input_matrix, sketch_size, seed=None):
+@_transition_to_rng("seed", position_num=2)
+def clarkson_woodruff_transform(input_matrix, sketch_size, rng=None):
     r"""
     Applies a Clarkson-Woodruff Transform/sketch to the input matrix.
 
@@ -71,13 +72,11 @@ def clarkson_woodruff_transform(input_matrix, sketch_size, seed=None):
         Input matrix, of shape ``(n, d)``.
     sketch_size : int
         Number of rows for the sketch.
-    seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional
-        If `seed` is None (or `np.random`), the `numpy.random.RandomState`
-        singleton is used.
-        If `seed` is an int, a new ``RandomState`` instance is used,
-        seeded with `seed`.
-        If `seed` is already a ``Generator`` or ``RandomState`` instance then
-        that instance is used.
+    rng : `numpy.random.Generator`, optional
+        Pseudorandom number generator state. When `rng` is None, a new
+        `numpy.random.Generator` is created using entropy from the
+        operating system. Types other than `numpy.random.Generator` are
+        passed to `numpy.random.default_rng` to instantiate a ``Generator``.
 
     Returns
     -------
@@ -175,5 +174,5 @@ def clarkson_woodruff_transform(input_matrix, sketch_size, seed=None):
     166.58473879945151
 
     """
-    S = cwt_matrix(sketch_size, input_matrix.shape[0], seed)
+    S = cwt_matrix(sketch_size, input_matrix.shape[0], rng=rng)
     return S.dot(input_matrix)

scipy/linalg/tests/test_sketches.py

@@ -13,7 +13,7 @@ class TestClarksonWoodruffTransform:
     Testing the Clarkson Woodruff Transform
     """
     # set seed for generating test matrices
-    rng = np.random.RandomState(seed=1179103485)
+    rng = np.random.default_rng(1179103485)
 
     # Test matrix parameters
     n_rows = 2000
@@ -27,7 +27,7 @@ class TestClarksonWoodruffTransform:
     seeds = [1755490010, 934377150, 1391612830, 1752708722, 2008891431,
              1302443994, 1521083269, 1501189312, 1126232505, 1533465685]
 
-    A_dense = rng.randn(n_rows, n_cols)
+    A_dense = rng.random((n_rows, n_cols))
     A_csc = rand(
         n_rows, n_cols, density=density, format='csc', random_state=rng,
     )
@@ -44,11 +44,12 @@ class TestClarksonWoodruffTransform:
     ]
 
     # Test vector with norm ~1
-    x = rng.randn(n_rows, 1) / np.sqrt(n_rows)
+    x = rng.random((n_rows, 1)) / np.sqrt(n_rows)
 
     def test_sketch_dimensions(self):
         for A in self.test_matrices:
             for seed in self.seeds:
+                # seed to ensure backwards compatibility post SPEC7
                 sketch = clarkson_woodruff_transform(
                     A, self.n_sketch_rows, seed=seed
                 )
@@ -57,21 +58,21 @@ def test_sketch_dimensions(self):
     def test_seed_returns_identical_transform_matrix(self):
         for seed in self.seeds:
             S1 = cwt_matrix(
-                self.n_sketch_rows, self.n_rows, seed=seed
+                self.n_sketch_rows, self.n_rows, rng=seed
             ).toarray()
             S2 = cwt_matrix(
-                self.n_sketch_rows, self.n_rows, seed=seed
+                self.n_sketch_rows, self.n_rows, rng=seed
             ).toarray()
             assert_equal(S1, S2)
 
     def test_seed_returns_identically(self):
         for A in self.test_matrices:
             for seed in self.seeds:
                 sketch1 = clarkson_woodruff_transform(
-                    A, self.n_sketch_rows, seed=seed
+                    A, self.n_sketch_rows, rng=seed
                 )
                 sketch2 = clarkson_woodruff_transform(
-                    A, self.n_sketch_rows, seed=seed
+                    A, self.n_sketch_rows, rng=seed
                 )
                 if issparse(sketch1):
                     sketch1 = sketch1.toarray()
@@ -91,7 +92,7 @@ def test_sketch_preserves_frobenius_norm(self):
                 true_norm = np.linalg.norm(A)
             for seed in self.seeds:
                 sketch = clarkson_woodruff_transform(
-                    A, self.n_sketch_rows, seed=seed,
+                    A, self.n_sketch_rows, rng=seed,
                 )
                 if issparse(sketch):
                     sketch_norm = norm(sketch)
@@ -108,7 +109,7 @@ def test_sketch_preserves_vector_norm(self):
         true_norm = np.linalg.norm(self.x)
         for seed in self.seeds:
             sketch = clarkson_woodruff_transform(
-                self.x, n_sketch_rows, seed=seed,
+                self.x, n_sketch_rows, rng=seed,
             )
             sketch_norm = np.linalg.norm(sketch)