Rand generators (#100)

* Non-functional change:
* Fix numpy deprecation warning, logic should be equivalent

* Tenrand initial implementation

* Sptenrand initial implementation

Author: ntjohnson1

pyttb/__init__.py

@@ -15,13 +15,13 @@
 from pyttb.ktensor import ktensor
 from pyttb.pyttb_utils import *
 from pyttb.sptenmat import sptenmat
-from pyttb.sptensor import sptendiag, sptensor
+from pyttb.sptensor import sptendiag, sptenrand, sptensor
 from pyttb.sptensor3 import sptensor3
 from pyttb.sumtensor import sumtensor
 from pyttb.symktensor import symktensor
 from pyttb.symtensor import symtensor
 from pyttb.tenmat import tenmat
-from pyttb.tensor import tendiag, tenones, tensor, tenzeros
+from pyttb.tensor import tendiag, tenones, tenrand, tensor, tenzeros
 from pyttb.ttensor import ttensor
 from pyttb.tucker_als import tucker_als
 

pyttb/sptensor.py

@@ -196,7 +196,7 @@ def from_tensor_type(
     @classmethod
     def from_function(
         cls,
-        function_handle: Callable[[Tuple[float, float]], np.ndarray],
+        function_handle: Callable[[Tuple[int, ...]], np.ndarray],
         shape: Tuple[int, ...],
         nonzeros: float,
     ) -> sptensor:
@@ -1049,7 +1049,7 @@ def scale(self, factor: np.ndarray, dims: Union[float, np.ndarray]) -> sptensor:
 
         if isinstance(factor, ttb.tensor):
             shapeArray = np.array(self.shape)
-            if np.any(factor.shape != shapeArray[dims]):
+            if not np.array_equal(factor.shape, shapeArray[dims]):
                 assert False, "Size mismatch in scale"
             return ttb.sptensor.from_data(
                 self.subs,
@@ -1058,7 +1058,7 @@ def scale(self, factor: np.ndarray, dims: Union[float, np.ndarray]) -> sptensor:
             )
         if isinstance(factor, ttb.sptensor):
             shapeArray = np.array(self.shape)
-            if np.any(factor.shape != shapeArray[dims]):
+            if not np.array_equal(factor.shape, shapeArray[dims]):
                 assert False, "Size mismatch in scale"
             return ttb.sptensor.from_data(
                 self.subs, self.vals * factor.extract(self.subs[:, dims]), self.shape
@@ -2585,6 +2585,55 @@ def ttm(
         return ttb.tensor.from_tensor_type(Ynt)
 
 
+def sptenrand(
+    shape: Tuple[int, ...],
+    density: Optional[float] = None,
+    nonzeros: Optional[float] = None,
+) -> sptensor:
+    """
+    Create sptensor with entries drawn from a uniform distribution on the unit interval
+
+    Parameters
+    ----------
+    shape: Shape of resulting tensor
+    density: Density of resulting sparse tensor
+    nonzeros: Number of nonzero entries in resulting sparse tensor
+
+    Returns
+    -------
+    Constructed tensor
+
+    Example
+    -------
+    >>> X = ttb.sptenrand((2,2), nonzeros=1)
+    >>> Y = ttb.sptenrand((2,2), density=0.25)
+    """
+    if density is None and nonzeros is None:
+        raise ValueError("Must set either density or nonzeros")
+
+    if density is not None and nonzeros is not None:
+        raise ValueError("Must set either density or nonzeros but not both")
+
+    if density is not None and not 0 < density <= 1:
+        raise ValueError(f"Density must be a fraction (0, 1] but received {density}")
+
+    if isinstance(density, float):
+        valid_nonzeros = float(np.prod(shape) * density)
+    elif isinstance(nonzeros, (int, float)):
+        valid_nonzeros = nonzeros
+    else:  # pragma: no cover
+        raise ValueError(
+            f"Incorrect types for density:{density} and nonzeros:{nonzeros}"
+        )
+
+    # Typing doesn't play nice with partial
+    # mypy issue: 1484
+    def unit_uniform(pass_through_shape: Tuple[int, ...]) -> np.ndarray:
+        return np.random.uniform(low=0, high=1, size=pass_through_shape)
+
+    return ttb.sptensor.from_function(unit_uniform, shape, valid_nonzeros)
+
+
 def sptendiag(
     elements: np.ndarray, shape: Optional[Tuple[int, ...]] = None
 ) -> sptensor:

pyttb/tensor.py

@@ -1873,6 +1873,31 @@ def tenzeros(shape: Tuple[int, ...]) -> tensor:
     return tensor.from_function(np.zeros, shape)
 
 
+def tenrand(shape: Tuple[int, ...]) -> tensor:
+    """
+    Creates a tensor with entries drawn from a uniform distribution on the unit interval
+
+    Parameters
+    ----------
+    shape: Shape of resulting tensor
+
+    Returns
+    -------
+    Constructed tensor
+
+    Example
+    -------
+    >>> X = ttb.tenrand((2,2))
+    """
+
+    # Typing doesn't play nice with partial
+    # mypy issue: 1484
+    def unit_uniform(pass_through_shape: Tuple[int, ...]) -> np.ndarray:
+        return np.random.uniform(low=0, high=1, size=pass_through_shape)
+
+    return tensor.from_function(unit_uniform, shape)
+
+
 def tendiag(elements: np.ndarray, shape: Optional[Tuple[int, ...]] = None) -> tensor:
     """
     Creates a tensor with elements along super diagonal

tests/test_sptensor.py

@@ -1789,3 +1789,38 @@ def test_sptendiag():
     for i in range(N):
         diag_index = (i,) * N
         assert X[diag_index] == i
+
+
+def test_sptenrand():
+    arbitrary_shape = (3, 3, 3)
+    rand_tensor = ttb.sptenrand(arbitrary_shape, nonzeros=1)
+    in_unit_interval = np.all(0 <= rand_tensor.vals <= 1)
+    assert (
+        in_unit_interval
+        and rand_tensor.shape == arbitrary_shape
+        and rand_tensor.nnz == 1
+    )
+
+    rand_tensor = ttb.sptenrand(arbitrary_shape, density=1 / np.prod(arbitrary_shape))
+    in_unit_interval = np.all(0 <= rand_tensor.vals <= 1)
+    assert (
+        in_unit_interval
+        and rand_tensor.shape == arbitrary_shape
+        and rand_tensor.nnz == 1
+    )
+
+    # Negative tests
+    # Bad density
+    with pytest.raises(ValueError):
+        ttb.sptenrand(arbitrary_shape, density=-1)
+        ttb.sptenrand(arbitrary_shape, density=2)
+
+    # Missing args
+    # Bad density
+    with pytest.raises(ValueError):
+        ttb.sptenrand(arbitrary_shape)
+
+    # Redundant/contradicting args
+    # Bad density
+    with pytest.raises(ValueError):
+        ttb.sptenrand(arbitrary_shape, density=0.5, nonzeros=2)

tests/test_tensor.py

@@ -1643,6 +1643,15 @@ def test_tenzeros():
     assert np.equal(zeros_tensor, data_tensor), "Tenzeros should match all zeros tensor"
 
 
+def test_tenrand():
+    arbitrary_shape = (3, 3, 3)
+    rand_tensor = ttb.tenrand(arbitrary_shape)
+    in_unit_interval = np.all((rand_tensor >= 0).data) and np.all(
+        (rand_tensor <= 1).data
+    )
+    assert in_unit_interval and rand_tensor.shape == arbitrary_shape
+
+
 def test_tendiag():
     N = 4
     elements = np.arange(0, N)