Merge pull request #148 from tushushu/wip-i64-f64

Support int64 and f64 types

Author: tushushu

docs/conf.py

@@ -22,7 +22,7 @@
 author = 'tushushu'
 
 # The full version, including alpha/beta/rc tags
-release = '0.8.0'
+release = '0.9.0'
 
 
 # -- General configuration ---------------------------------------------------

tests/test_base.py

@@ -3,14 +3,15 @@
 import operator as op
 import pytest
 import ulist as ul
-from ulist.utils import check_test_result
+from ulist.utils import check_test_result, compare_dtypes, expand_dtypes
 
 ELEM_TYPE = Union[float, int, bool, str]
 LIST_TYPE = Union[List[float], List[int], List[bool], List[str]]
 COUNTER = Union[Dict[int, int], Dict[bool, int]]
 RESULT = Union[ELEM_TYPE, LIST_TYPE, COUNTER]
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "test_method, dtype, nums, expected_value",
     [
@@ -125,6 +126,7 @@ def test_methods_no_arg(
     check_test_result(dtype, test_method, result, expected_value)
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "test_method, dtype, nums, expected_value, kwargs",
     [
@@ -150,21 +152,6 @@ def test_methods_no_arg(
         ("apply", "string", ['foo', 'bar'], [
          True, False], {"fn": lambda x: x != 'bar'},),
 
-        ('astype', 'bool', [True, False], [1, 0], {'dtype': 'int'}),
-        ('astype', 'bool', [True, False], [1.0, 0.0], {'dtype': 'float'}),
-        ('astype', 'bool', [True, False], [True, False], {'dtype': 'bool'}),
-
-        ('astype', 'float', [1.0, 2.0, 3.0], [1, 2, 3], {'dtype': 'int'}),
-        ('astype', 'float', [1.0, 2.0, 3.0], [
-         1.0, 2.0, 3.0], {'dtype': 'float'}),
-        ('astype', 'float', [-2.0, -1.0, 0.0, 1.0, 2.0],
-         [True, True, False, True, True], {'dtype': 'bool'}),
-
-        ('astype', 'int', [1, 2, 3], [1, 2, 3], {'dtype': 'int'}),
-        ('astype', 'int', [1, 2, 3], [1.0, 2.0, 3.0], {'dtype': 'float'}),
-        ('astype', 'int', [-2, -1, 0, 1, 2],
-         [True, True, False, True, True], {'dtype': 'bool'}),
-
         ("equal_scala", 'bool', [True, False], [False, True], {"elem": False}),
         ("equal_scala", 'float', [1.0, 2.0, 3.0],
          [False, True, False], {"elem": 2.0}),
@@ -335,6 +322,7 @@ def test_methods_with_args(
     check_test_result(dtype, test_method, result, expected_value)
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "test_method, dtype, nums, expected_value, kwargs",
     [
@@ -376,6 +364,7 @@ def test_multable_methods(
     check_test_result(dtype, test_method, arr, expected_value)
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "dtype, nums, expected_value, kwargs",
     [
@@ -407,6 +396,7 @@ def test_indexing_operations(
     check_test_result(dtype, test_method, result, expected_value)
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "dtype, nums, expected_value, expected_dtype",
     [
@@ -451,7 +441,7 @@ def test_astype(
     result = arr.astype(expected_dtype)
     test_method = f"astype {expected_dtype}"
     check_test_result(dtype, test_method, result, expected_value)
-    assert result.dtype == expected_dtype
+    assert compare_dtypes(result.dtype, expected_dtype)
     assert id(result) != id(arr)
 
     # Cast back to origin type
@@ -461,6 +451,7 @@ def test_astype(
         check_test_result(expected_dtype, test_method, arr1, arr.to_list())
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "test_method, dtype, nums, expected_value, kwargs",
     [

tests/test_constructors.py

@@ -9,6 +9,10 @@
     "test_method, args, kwargs, expected_value",
     [
         (ul.arange, (3,), {}, [0, 1, 2],),
+        (ul.arange, (3,), {"dtype": "int"}, [0, 1, 2],),
+        (ul.arange, (3,), {"dtype": "int32"}, [0, 1, 2],),
+        (ul.arange, (3,), {"dtype": "int64"}, [0, 1, 2],),
+
         (ul.arange, (0, 3,), {}, [0, 1, 2],),
         (ul.arange, (0, 4, 2,), {}, [0, 2],),
         (ul.arange, (0, 5, 2,), {}, [0, 2, 4],),
@@ -26,6 +30,8 @@
 
         (ul.from_seq, (range(3), "float"), {}, [0.0, 1.0, 2.0],),
         (ul.from_seq, (range(3), "int"), {}, [0, 1, 2],),
+        (ul.from_seq, (range(3), "int32"), {}, [0, 1, 2],),
+        (ul.from_seq, (range(3), "int64"), {}, [0, 1, 2],),
 
         (ul.from_seq, ([False, True], "bool"), {}, [False, True],),
         (ul.from_seq, ([0.0, 1.0, 2.0], "float"), {}, [0.0, 1.0, 2.0],),
@@ -38,6 +44,8 @@
         (ul.from_seq, (('foo', 'bar'), "string"), {}, ['foo', 'bar'],),
 
         (ul.cycle, (range(3), 1, 'float'), {}, [0.0],),
+        (ul.cycle, (range(3), 1, 'int32'), {}, [0],),
+        (ul.cycle, (range(3), 1, 'int64'), {}, [0],),
         (ul.cycle, (range(3), 1, 'int'), {}, [0],),
         (ul.cycle, (range(3), 2, 'int'), {}, [0, 1],),
         (ul.cycle, (range(3), 3, 'int'), {}, [0, 1, 2],),

tests/test_control_flow.py

@@ -3,11 +3,12 @@
 import pytest
 import ulist as ul
 import operator as op
-from ulist.utils import check_test_result
+from ulist.utils import check_test_result, expand_dtypes
 
 LIST_TYPE = Union[List[float], List[int], List[bool], List[str]]
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "dtype, nums, kwargs, expected_value",
     [
@@ -200,6 +201,7 @@ def test_select(
     check_test_result(result_dtype, "ul.select", result, expected_value)
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "dtype, nums, kwargs, expected_value",
     [

tests/test_numerical.py

@@ -3,12 +3,13 @@
 
 import pytest
 import ulist as ul
-from ulist.utils import check_test_result
+from ulist.utils import check_test_result, expand_dtypes
 
 NUM_TYPE = Union[float, int]
 LIST_TYPE = Union[List[float], List[int]]
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "test_method, dtype, nums, expected_value",
     [
@@ -44,6 +45,7 @@ def test_statistics_methods(
     check_test_result(dtype, test_method, result, expected_value)
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "test_method, dtype, nums, expected_value, kwargs",
     [
@@ -130,6 +132,7 @@ def test_arithmetic_methods(
     check_test_result(dtype, test_method, result, expected_value)
 
 
+@expand_dtypes
 @pytest.mark.parametrize(
     "test_method, dtype, nums, expected_value, kwargs",
     [

ulist/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ulist"
-version = "0.8.0"
+version = "0.9.0"
 authors = ["tushushu"]
 edition = "2018"
 

ulist/python/ulist/__init__.py

@@ -3,4 +3,4 @@
 from .core import UltraFastList  # noqa:F401
 from .ulist import IndexList  # noqa:F401
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"

ulist/python/ulist/constructor.py

@@ -1,13 +1,25 @@
 from typing import Optional, Sequence
 
 from .core import UltraFastList
-from .ulist import BooleanList, FloatList, IntegerList, StringList
-from .ulist import arange as _arange
 from .typedef import ELEM
-
-
-def arange(start: int, stop: Optional[int] = None, step: int = 1
-           ) -> UltraFastList:
+from .ulist import (
+    BooleanList,
+    FloatList32,
+    FloatList64,
+    IntegerList32,
+    IntegerList64,
+    StringList,
+    arange32,
+    arange64
+)
+
+
+def arange(
+    start: int,
+    stop: Optional[int] = None,
+    step: int = 1,
+    dtype: str = 'int',
+) -> UltraFastList:
     """Return evenly spaced values within a given interval, which is similar
     to the Python built-in range function, but returns an ulist rather than
     a list.
@@ -21,6 +33,8 @@ def arange(start: int, stop: Optional[int] = None, step: int = 1
             Defaults to None.
         step (int, optional):
             Spacing between values. Defaults to 1.
+        dtype (str, optional):
+            The type of the output ulist. 'int', 'int32', 'int64'.
 
     Returns:
         UltraFastList: A ulist object.
@@ -43,7 +57,13 @@ def arange(start: int, stop: Optional[int] = None, step: int = 1
     if stop is None:
         stop = start
         start = 0
-    return UltraFastList(_arange(start=start, stop=stop, step=step))
+    if dtype == "int" or dtype == "int64":
+        return UltraFastList(arange64(start=start, stop=stop, step=step))
+    elif dtype == "int32":
+        return UltraFastList(arange32(start=start, stop=stop, step=step))
+    else:
+        raise ValueError(
+            "Parameter dtype should be 'int', 'int32' or 'int64'!")
 
 
 def cycle(obj: Sequence, size: int, dtype: str) -> UltraFastList:
@@ -55,11 +75,13 @@ def cycle(obj: Sequence, size: int, dtype: str) -> UltraFastList:
         size (int):
             size (int): Size of the new ulist.
         dtype (str):
-            The type of the output ulist. 'int', 'float', 'bool' or 'string'.
+            The type of the output ulist. 'int', 'int32', 'int64',
+            'float', 'float32', 'float64', 'bool' or 'string'.
 
     Raises:
         ValueError:
-            Parameter dtype should be 'int', 'float', 'bool' or 'string'!
+            Parameter dtype should be 'int', 'int32', 'int64',
+            'float', 'float32', 'float64', 'bool' or 'string'!
 
     Returns:
         UltraFastList: A ulist object.
@@ -83,17 +105,23 @@ def cycle(obj: Sequence, size: int, dtype: str) -> UltraFastList:
     >>> arr4
     UltraFastList(['foo', 'foo', 'foo'])
     """
-    if dtype == "int":
-        result = UltraFastList(IntegerList.cycle(obj, size))
-    elif dtype == "float":
-        result = UltraFastList(FloatList.cycle(obj, size))
+    if dtype == "int" or dtype == "int64":
+        result = UltraFastList(IntegerList64.cycle(obj, size))
+    elif dtype == "int32":
+        result = UltraFastList(IntegerList32.cycle(obj, size))
+    elif dtype == "float" or dtype == "float64":
+        result = UltraFastList(FloatList64.cycle(obj, size))
+    elif dtype == "float32":
+        result = UltraFastList(FloatList32.cycle(obj, size))
     elif dtype == "bool":
         result = UltraFastList(BooleanList.cycle(obj, size))
     elif dtype == "string":
         result = UltraFastList(StringList.cycle(obj, size))
     else:
         raise ValueError(
-            "Parameter dtype should be 'int', 'float', 'bool' or 'string'!")
+            "Parameter dtype should be 'int', 'int32', 'int64', " +
+            "'float', 'float32', 'float64', 'bool' or 'string'!"
+        )
     return result
 
 
@@ -104,11 +132,13 @@ def from_seq(obj: Sequence, dtype: str) -> UltraFastList:
         obj (Sequence):
             Sequence object such as list, tuple and range.
         dtype (str):
-            The type of the output ulist. 'int', 'float', 'bool' or 'string'.
+            The type of the output ulist. 'int', 'int32', 'int64',
+            'float', 'float32', 'float64', 'bool' or 'string'.
 
     Raises:
         ValueError:
-            Parameter dtype should be 'int', 'float', 'bool' or 'string'!
+            Parameter dtype should be 'int', 'int32', 'int64',
+            'float', 'float32', 'float64', 'bool' or 'string'!
 
     Returns:
         UltraFastList: A ulist object.
@@ -132,17 +162,23 @@ def from_seq(obj: Sequence, dtype: str) -> UltraFastList:
     >>> arr4
     UltraFastList(['foo', 'bar', 'baz'])
     """
-    if dtype == "int":
-        result = UltraFastList(IntegerList(obj))
-    elif dtype == "float":
-        result = UltraFastList(FloatList(obj))
+    if dtype == "int" or dtype == "int64":
+        result = UltraFastList(IntegerList64(obj))
+    elif dtype == "int32":
+        result = UltraFastList(IntegerList32(obj))
+    elif dtype == "float" or dtype == "float64":
+        result = UltraFastList(FloatList64(obj))
+    elif dtype == "float32":
+        result = UltraFastList(FloatList32(obj))
     elif dtype == "bool":
         result = UltraFastList(BooleanList(obj))
     elif dtype == "string":
         result = UltraFastList(StringList(obj))
     else:
         raise ValueError(
-            "Parameter dtype should be 'int', 'float', 'bool' or 'string'!")
+            "Parameter dtype should be 'int', 'int32', 'int64', " +
+            "'float', 'float32', 'float64', 'bool' or 'string'!"
+        )
     return result
 
 
@@ -181,9 +217,9 @@ def repeat(elem: ELEM, size: int) -> UltraFastList:
     if isinstance(elem, bool):
         return UltraFastList(BooleanList.repeat(elem, size))
     elif isinstance(elem, float):
-        return UltraFastList(FloatList.repeat(elem, size))
+        return UltraFastList(FloatList64.repeat(elem, size))
     elif isinstance(elem, int):
-        return UltraFastList(IntegerList.repeat(elem, size))
+        return UltraFastList(IntegerList64.repeat(elem, size))
     elif isinstance(elem, str):
         return UltraFastList(StringList.repeat(elem, size))
     else: