Merge pull request #209 from Rust-Data-Science/wip-rand-choice

Wip rand choice

Author: tushushu

requirements/common.txt

@@ -1,2 +1,2 @@
 # A-Z
-maturin==0.12.6
+maturin==0.13.7

tests/test_constructors.py

@@ -104,3 +104,28 @@ def test_rand(
     assert arr1.not_equal(arr2).all()
     assert len(arr1) == len(arr2)
     assert len(arr1) == kwargs["size"]
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"obj": list(range(1000)), "size": 1000, "dtype": "float"},
+        {"obj": list(range(1000)), "size": 1000, "dtype": "float32"},
+        {"obj": list(range(1000)), "size": 1000, "dtype": "float64"},
+        {"obj": list(range(1000)), "size": 1000, "dtype": "int"},
+        {"obj": list(range(1000)), "size": 1000, "dtype": "int32"},
+        {"obj": list(range(1000)), "size": 1000, "dtype": "int64"},
+        {"obj": [True, False], "size": 1000, "dtype": "bool"},
+        {"obj": ['foo', 'bar'], "size": 1000, "dtype": "string"},
+    ],
+)
+def test_choices(kwargs: dict) -> None:
+    arr1 = ul.choices(**kwargs)
+    arr2 = ul.choices(**kwargs)
+    assert all([x in kwargs["obj"] for x in arr1.to_list()])
+    assert all([x in kwargs["obj"] for x in arr2.to_list()])
+    assert arr1.not_equal(arr2).any()
+    assert len(arr1) == len(arr2)
+    assert len(arr1) == kwargs["size"]
+    assert arr1.dtype.startswith(kwargs["dtype"])
+    assert arr2.dtype.startswith(kwargs["dtype"])

ulist/python/ulist/__init__.py

@@ -1,4 +1,4 @@
-from .constructor import arange, cycle, from_seq, random, repeat  # noqa:F401
+from .constructor import arange, choices, cycle, from_seq, random, repeat  # noqa:F401, E501
 from .control_flow import select  # noqa:F401
 from .core import UltraFastList  # noqa:F401
 from .io import read_csv  # noqa:F401

ulist/python/ulist/constructor.py

@@ -67,6 +67,47 @@ def arange(
             "Parameter dtype should be 'int', 'int32' or 'int64'!")
 
 
+def choices(obj: Sequence, size: int, dtype: str) -> UltraFastList:
+    """Choose element from a sequence randomly and endlessly until
+    the size is met.
+
+    Args:
+        obj (Sequence):
+            Sequence object such as list, tuple and range.
+        size (int):
+            size (int): Size of the new ulist.
+        dtype (str):
+            The type of the output ulist. 'int', 'int32', 'int64',
+            'float', 'float32', 'float64', 'bool' or 'string'.
+
+    Raises:
+        ValueError:
+            Parameter dtype should be 'int', 'int32', 'int64',
+            'float', 'float32', 'float64', 'bool' or 'string'!
+
+    Returns:
+        UltraFastList: A ulist object.
+    """
+    if dtype == "int" or dtype == "int64":
+        result = UltraFastList(IntegerList64.choices(obj, size))
+    elif dtype == "int32":
+        result = UltraFastList(IntegerList32.choices(obj, size))
+    elif dtype == "float" or dtype == "float64":
+        result = UltraFastList(FloatList64.choices(obj, size))
+    elif dtype == "float32":
+        result = UltraFastList(FloatList32.choices(obj, size))
+    elif dtype == "bool":
+        result = UltraFastList(BooleanList.choices(obj, size))
+    elif dtype == "string":
+        result = UltraFastList(StringList.choices(obj, size))
+    else:
+        raise ValueError(
+            "Parameter dtype should be 'int', 'int32', 'int64', " +
+            "'float', 'float32', 'float64', 'bool' or 'string'!"
+        )
+    return result
+
+
 def cycle(obj: Sequence, size: int, dtype: str) -> UltraFastList:
     """Repeats a sequence endlessly until the size is met.
 

ulist/python/ulist/ulist.pyi

@@ -17,6 +17,8 @@ class BooleanList:
     def as_int32(self) -> IntegerList32: ...
     def as_int64(self) -> IntegerList64: ...
     def as_str(self) -> StringList: ...
+    @staticmethod
+    def choices(obj: Sequence[bool], size: int) -> BooleanList: ...
     def copy(self) -> BooleanList: ...
     def count_na(self) -> int: ...
     def counter(self) -> Dict[Optional[bool], int]: ...
@@ -60,6 +62,8 @@ class FloatList32:
     def as_int32(self) -> IntegerList32: ...
     def as_int64(self) -> IntegerList64: ...
     def as_str(self) -> StringList: ...
+    @staticmethod
+    def choices(obj: Sequence[float], size: int) -> FloatList32: ...
     def copy(self) -> FloatList32: ...
     def count_na(self) -> int: ...
     @staticmethod
@@ -119,6 +123,8 @@ class FloatList64:
     def as_int32(self) -> IntegerList32: ...
     def as_int64(self) -> IntegerList64: ...
     def as_str(self) -> StringList: ...
+    @staticmethod
+    def choices(obj: Sequence[float], size: int) -> FloatList64: ...
     def copy(self) -> FloatList64: ...
     def count_na(self) -> int: ...
     @staticmethod
@@ -178,6 +184,8 @@ class IntegerList32:
     def as_float64(self) -> FloatList64: ...
     def as_int64(self) -> IntegerList64: ...
     def as_str(self) -> StringList: ...
+    @staticmethod
+    def choices(obj: Sequence[int], size: int) -> IntegerList32: ...
     def copy(self) -> IntegerList32: ...
     def count_na(self) -> int: ...
     def counter(self) -> Dict[Optional[int], int]: ...
@@ -236,6 +244,8 @@ class IntegerList64:
     def as_float64(self) -> FloatList64: ...
     def as_int32(self) -> IntegerList32: ...
     def as_str(self) -> StringList: ...
+    @staticmethod
+    def choices(obj: Sequence[int], size: int) -> IntegerList64: ...
     def copy(self) -> IntegerList64: ...
     def count_na(self) -> int: ...
     def counter(self) -> Dict[Optional[int], int]: ...
@@ -290,6 +300,8 @@ class StringList:
     def as_float64(self) -> FloatList64: ...
     def as_int32(self) -> IntegerList32: ...
     def as_int64(self) -> IntegerList64: ...
+    @staticmethod
+    def choices(obj: Sequence[str], size: int) -> StringList: ...
     def contains(self, elem: str) -> BooleanList: ...
     def copy(self) -> StringList: ...
     def count_na(self) -> int: ...

ulist/src/base.rs

@@ -3,6 +3,8 @@ use crate::index::IndexList;
 use pyo3::exceptions::PyIndexError;
 use pyo3::exceptions::PyRuntimeError;
 use pyo3::PyResult;
+use rand::distributions::Uniform;
+use rand::Rng;
 use std::cell::Ref;
 use std::cell::RefMut;
 use std::collections::HashSet;
@@ -108,6 +110,17 @@ where
         }
     }
 
+    fn choices(vec: &[T], size: usize) -> Self {
+        let n = vec.len();
+        let dist: Uniform<usize> = Uniform::from(0..n);
+        let v = rand::thread_rng()
+            .sample_iter(dist)
+            .map(|x| unsafe { vec.get_unchecked(x).clone() })
+            .take(size)
+            .collect();
+        List::_new(v, HashSet::new())
+    }
+
     fn copy(&self) -> Self {
         let hset = self.na_indexes().clone();
         List::_new(self.values().clone(), hset)
@@ -232,7 +245,7 @@ where
         let n = self.size();
         let mut vec = self.values_mut();
         for i in 0..n {
-            let ptr = unsafe{ vec.get_unchecked_mut(i)};
+            let ptr = unsafe { vec.get_unchecked_mut(i) };
             if *ptr == old {
                 *ptr = self.na_value();
                 self.na_indexes_mut().insert(i);
@@ -265,7 +278,7 @@ where
             return Err(PyIndexError::new_err("Index out of range!"));
         }
         let mut vec = self.values_mut();
-        let ptr = unsafe{vec.get_unchecked_mut(index)};
+        let ptr = unsafe { vec.get_unchecked_mut(index) };
         if let Some(i) = elem {
             *ptr = i;
             self.na_indexes_mut().remove(&index);

ulist/src/boolean.rs

@@ -137,6 +137,11 @@ impl BooleanList {
         NonFloatList::counter(self)
     }
 
+    #[staticmethod]
+    pub fn choices(vec: Vec<bool>, size: usize) -> Self {
+        List::choices(&vec, size)
+    }
+
     #[staticmethod]
     pub fn cycle(vec: Vec<bool>, size: usize) -> Self {
         List::cycle(&vec, size)

ulist/src/floatings/float32.rs

@@ -79,6 +79,11 @@ impl FloatList32 {
         AsStringList::as_str(self)
     }
 
+    #[staticmethod]
+    pub fn choices(vec: Vec<f32>, size: usize) -> Self {
+        List::choices(&vec, size)
+    }
+
     pub fn copy(&self) -> Self {
         List::copy(self)
     }
@@ -192,8 +197,8 @@ impl FloatList32 {
 
     #[staticmethod]
     fn random(size: usize) -> Self {
-        let range: Uniform<f32> = Uniform::from(0.0..1.0);
-        let v: Vec<f32> = rand::thread_rng().sample_iter(&range).take(size).collect();
+        let dist: Uniform<f32> = Uniform::from(0.0..1.0);
+        let v: Vec<f32> = rand::thread_rng().sample_iter(&dist).take(size).collect();
         FloatList32::new(v, HashSet::new())
     }
 

ulist/src/floatings/float64.rs

@@ -79,6 +79,11 @@ impl FloatList64 {
         AsStringList::as_str(self)
     }
 
+    #[staticmethod]
+    pub fn choices(vec: Vec<f64>, size: usize) -> Self {
+        List::choices(&vec, size)
+    }
+
     pub fn copy(&self) -> Self {
         List::copy(self)
     }
@@ -192,8 +197,8 @@ impl FloatList64 {
 
     #[staticmethod]
     fn random(size: usize) -> Self {
-        let range: Uniform<f64> = Uniform::from(0.0..1.0);
-        let v: Vec<f64> = rand::thread_rng().sample_iter(&range).take(size).collect();
+        let dist: Uniform<f64> = Uniform::from(0.0..1.0);
+        let v: Vec<f64> = rand::thread_rng().sample_iter(&dist).take(size).collect();
         FloatList64::new(v, HashSet::new())
     }
 

ulist/src/integers/int32.rs

@@ -79,6 +79,11 @@ impl IntegerList32 {
         AsStringList::as_str(self)
     }
 
+    #[staticmethod]
+    pub fn choices(vec: Vec<i32>, size: usize) -> Self {
+        List::choices(&vec, size)
+    }
+
     pub fn copy(&self) -> Self {
         List::copy(self)
     }