0.4.2 (#44)

* Add a set of functions from r-base

* Rename datar_versions to get_versions

* Add varname to requirements to close #30

* 0.4.2

Author: pwwang

datar/__init__.py

@@ -6,10 +6,10 @@
 from .core import _frame_format_patch
 from .core.defaults import f
 
-__all__ = ('f', 'datar_versions')
-__version__ = "0.4.1"
+__all__ = ('f', 'get_versions')
+__version__ = "0.4.2"
 
-def datar_versions(
+def get_versions(
     prnt: bool = True
 ) -> Mapping[str, str]: # pragma: no cover
     """Print or return related versions which help for bug reporting.

datar/base/__init__.py

@@ -25,11 +25,20 @@
     round as round_,
     sum as sum_,
     abs as abs_,
+    prod,
+    sign,
+    signif,
+    trunc,
+    exp,
+    log,
+    log2,
+    log10,
+    log1p
 )
 from .bessel import bessel_i, bessel_j, bessel_k, bessel_y
 from .casting import as_double, as_float, as_int, as_integer, as_numeric
 from .complex import arg, as_complex, conj, im, is_complex, mod, re as re_
-from .constants import LETTERS, Inf, letters, month_abb, month_name, pi
+from .constants import LETTERS, letters, month_abb, month_name, pi
 from .cum import cummax, cummin, cumprod, cumsum
 from .date import as_date
 from .factor import (
@@ -52,7 +61,7 @@
     is_logical,
     is_true,
 )
-from .na import NA, NaN, any_na, is_na
+from .na import NA, NaN, any_na, is_na, Inf, is_finite, is_infinite, is_nan
 from .null import NULL, as_null, is_null
 from .random import set_seed
 from .seq import (
@@ -66,6 +75,7 @@
     seq_along,
     seq_len,
     unique,
+    match
 )
 from .special import (
     beta,
@@ -99,6 +109,12 @@
     sub,
     substr,
     substring,
+    startswith,
+    endswith,
+    strtoi,
+    chartr,
+    tolower,
+    toupper,
 )
 from .table import table
 from .testing import (
@@ -145,6 +161,7 @@
     setequal,
     t,
     union,
+    max_col,
 )
 from .which import which, which_max, which_min
 

datar/base/arithmetic.py

@@ -6,10 +6,16 @@
 from pandas import DataFrame, Series
 from pipda import register_func, register_verb
 
-from ..core.contexts import Context
-from ..core.types import NumericOrIter, NumericType, is_not_null, is_scalar
-from ..core.utils import Array, register_numpy_func_x, recycle_value, length_of
 from ..core.collections import Collection
+from ..core.contexts import Context
+from ..core.types import (
+    FloatOrIter,
+    NumericOrIter,
+    NumericType,
+    is_not_null,
+    is_scalar
+)
+from ..core.utils import Array, length_of, recycle_value, register_numpy_func_x
 
 # cor?, range, summary, iqr
 
@@ -50,6 +56,20 @@ def _arithmetric(x: Iterable, na_rm: bool = False) -> Iterable:
     """,
 )
 
+prod = _register_arithmetic_agg(
+    "prod",
+    "prod",
+    doc="""Product of the input.
+
+    Args:
+        x: The input
+        na_rm: Exclude the NAs
+
+    Returns:
+        The product of the input
+    """,
+)
+
 mean = _register_arithmetic_agg(
     "mean",
     "mean",
@@ -161,6 +181,7 @@ def pmax(*x: Iterable, na_rm: bool = False) -> Iterable[float]:
 @register_func(None, context=Context.EVAL)
 def round(x: NumericOrIter, ndigits: int = 0) -> NumericOrIter:
     """Rounding a number"""
+    # recycle ndigits?
     return numpy.round(x, ndigits)
 
 
@@ -190,6 +211,33 @@ def round(x: NumericOrIter, ndigits: int = 0) -> NumericOrIter:
     """,
 )
 
+sign = register_numpy_func_x(
+    "sign",
+    "sign",
+    doc="""Get the signs of the corresponding elements of x
+
+    Args:
+        x: The input
+
+    Returns:
+        The signs of the corresponding elements of x
+    """,
+)
+
+trunc = register_numpy_func_x(
+    "trunc",
+    "trunc",
+    doc="""Get the integers truncated for each element in x
+
+    Args:
+        x: The input
+
+    Returns:
+        The ingeters of elements in x being truncated
+        Note the dtype is still float.
+    """,
+)
+
 ceiling = register_numpy_func_x(
     "ceiling",
     "ceil",
@@ -216,6 +264,27 @@ def round(x: NumericOrIter, ndigits: int = 0) -> NumericOrIter:
     """,
 )
 
+@register_func(None, context=Context.EVAL)
+def signif(
+    x: NumericOrIter,
+    digits: int = 6
+) -> NumericOrIter:
+    """Rounds the values in its first argument to the specified number of
+    significant digits
+
+    Args:
+        x: A numeric vector or scalar
+        digits: integer indicating the number of significant digits to be used
+
+    Returns:
+        The rounded values for each element in x
+    """
+    # todo complex?
+    return numpy.fromiter(
+        (round(elem, digits - int(ceiling(log10(abs(elem))))) for elem in x),
+        dtype=float
+    )
+
 # pylint: disable=unused-argument
 @register_verb(DataFrame, context=Context.EVAL)
 def cov(x: DataFrame, y: Iterable = None, ddof: int = 1) -> DataFrame:
@@ -501,3 +570,75 @@ def row_medians(
         The medians by row.
     """
     return x.agg(median, axis=1, na_rm=na_rm)
+
+@register_func(None, context=Context.EVAL)
+def log(x: NumericOrIter, base: float = numpy.e) -> FloatOrIter:
+    """Computes logarithms, by default natural logarithm
+
+    Args:
+        x: A numeric scalar or vector
+        base: The base of the logarithm
+
+    Returns:
+        The value of the logarithm if x is scalar, otherwise element-wise
+        logarithm of elements in x
+    """
+    if base == numpy.e:
+        return numpy.log(x)
+
+    return numpy.log(x) / numpy.log(base)
+
+exp = register_numpy_func_x(
+    "exp",
+    "exp",
+    doc="""Calculates the power of natural number
+
+    Args:
+        x: A numeric scalar or vector
+
+    Returns:
+        Power of natural number of element-wise power of natural number for x
+    """
+)
+
+log2 = register_numpy_func_x(
+    "log2",
+    "log2",
+    doc="""Computes logarithms with base 2
+
+    Args:
+        x: A numeric scalar or vector
+
+    Returns:
+        The value of log2 if x is scalar, otherwise element-wise
+        log2 of elements in x
+    """
+)
+
+log10 = register_numpy_func_x(
+    "log10",
+    "log10",
+    doc="""Computes logarithms with base 10
+
+    Args:
+        x: A numeric scalar or vector
+
+    Returns:
+        The value of log10 if x is scalar, otherwise element-wise
+        log10 of elements in x
+    """
+)
+
+log1p = register_numpy_func_x(
+    "log1p",
+    "log1p",
+    doc="""Computes log(1+x)
+
+    Args:
+        x: A numeric scalar or vector
+
+    Returns:
+        The value of log(1+x) if x is scalar, otherwise element-wise
+        log(1+x) of elements in x
+    """
+)

datar/base/constants.py

@@ -7,7 +7,6 @@
 # pylint: disable=invalid-name
 
 pi = math.pi
-Inf = numpy.inf
 
 letters = numpy.array(list(ascii_letters[:26]))
 LETTERS = numpy.array(list(ascii_letters[26:]))

datar/base/factor.py

@@ -45,13 +45,26 @@ def levels(x: Any) -> ArrayLikeType:
         x: The categorical data
 
     Returns:
-        levels of the categorical data
+        levels of the categorical
+        None if x is not an categorical/factor
     """
     if not is_categorical_(x):
         return None
 
     return categorized(x).categories
 
+@register_func(None, context=Context.EVAL)
+def nlevels(x: Any) -> int:
+    """Get the number of levels of a factor
+
+    Args:
+        x: The data to get number of levels of
+
+    Returns:
+        Number of levels if x is a categorical/factor; otherwise 0
+    """
+    lvls = levels(x)
+    return 0 if lvls is None else len(lvls)
 
 def factor(
     x: Iterable[Any] = None,

datar/base/funs.py

@@ -4,7 +4,8 @@
 registered by `register_verb` and should be placed in `./verbs.py`
 """
 import itertools
-from typing import Any, Iterable
+from typing import Any, Callable, Iterable, Union
+import numpy
 
 import pandas
 from pandas import Categorical, DataFrame
@@ -86,6 +87,25 @@ def expandgrid(*args: Iterable[Any], **kwargs: Iterable[Any]) -> DataFrame:
         list(itertools.product(*iters.values())), columns=iters.keys()
     )
 
+@register_func(None, context=Context.EVAL)
+def outer(x, y, fun: Union[str, Callable] = "*") -> DataFrame:
+    """Compute the outer product of two vectors.
+
+    Args:
+        x: The first vector
+        y: The second vector
+        fun: The function to handle how the result of the elements from
+            the first and second vectors should be computed.
+            The function has to be vectorized at the second argument, and
+            return the same shape as y.
+
+    Returns:
+        The data frame of the outer product of x and y
+    """
+    if fun == "*":
+        return DataFrame(numpy.outer(x, y))
+
+    return DataFrame([fun(xelem, y) for xelem in x])
 
 # ---------------------------------
 # Plain functions

datar/base/na.py

@@ -8,10 +8,12 @@
 from ..core.contexts import Context
 from ..core.types import is_null, is_scalar
 from ..core.defaults import NA_REPR
+from ..core.utils import register_numpy_func_x
 
 # pylint: disable=invalid-name
 NA = numpy.nan
 NaN = NA
+Inf = numpy.inf
 
 # Just for internal and testing uses
 NA_character_ = NA_REPR
@@ -58,3 +60,45 @@ def any_na(x: Any, recursive: bool = False) -> bool:
         if any_na(elem, recursive=True):
             return True
     return out
+
+is_infinite = register_numpy_func_x(
+    "is_infinite",
+    "isinf",
+    doc="""Check if a value or values are infinite numbers
+
+    Args:
+        x: The value to check
+
+    Returns:
+        True if the value is infinite, False otherwise
+        For iterable values, returns the element-wise results
+    """
+)
+
+is_finite = register_numpy_func_x(
+    "is_finite",
+    "isfinite",
+    doc="""Check if a value or values are finite numbers
+
+    Args:
+        x: The value to check
+
+    Returns:
+        True if the value is finite, False otherwise
+        For iterable values, returns the element-wise results
+    """
+)
+
+is_nan = register_numpy_func_x(
+    "is_nan",
+    "isnan",
+    doc="""Check if a value or values are NaNs
+
+    Args:
+        x: The value to check
+
+    Returns:
+        True if the value is nan, False otherwise
+        For iterable values, returns the element-wise results
+    """
+)