`ding.utils.loader.number`¶

`ding.utils.loader.number` ¶

`numeric(int_ok=True, float_ok=True, inf_ok=True)` ¶

Overview

Create a numeric loader.

Arguments: - int_ok (:obj:bool): Whether int is allowed. - float_ok (:obj:bool): Whether float is allowed. - inf_ok (:obj:bool): Whether inf is allowed.

`interval(left=None, right=None, left_ok=True, right_ok=True, eps=0.0)` ¶

Overview

Create a interval loader.

Arguments: - left (:obj:Optional[NUMBER_TYPING]): The left bound. - right (:obj:Optional[NUMBER_TYPING]): The right bound. - left_ok (:obj:bool): Whether left bound is allowed. - right_ok (:obj:bool): Whether right bound is allowed. - eps (:obj:float): The epsilon.

`is_negative()` ¶

Overview

Create a negative loader.

`is_positive()` ¶

Overview

Create a positive loader.

`non_negative()` ¶

Overview

Create a non-negative loader.

`non_positive()` ¶

Overview

Create a non-positive loader.

`negative()` ¶

Overview

Create a negative loader.

`positive()` ¶

Overview

Create a positive loader.

`plus(addend)` ¶

Overview

Create a plus loader.

Arguments: - addend (:obj:Any): The addend.

`minus(subtrahend)` ¶

Overview

Create a minus loader.

Arguments: - subtrahend (:obj:Any): The subtrahend.

`minus_with(minuend)` ¶

Overview

Create a minus loader.

Arguments: - minuend (:obj:Any): The minuend.

`multi(multiplier)` ¶

Overview

Create a multi loader.

Arguments: - multiplier (:obj:Any): The multiplier.

`divide(divisor)` ¶

Overview

Create a divide loader.

Arguments: - divisor (:obj:Any): The divisor.

`divide_with(dividend)` ¶

Overview

Create a divide loader.

Arguments: - dividend (:obj:Any): The dividend.

`power(index)` ¶

Overview

Create a power loader.

Arguments: - index (:obj:Any): The index.

`power_with(base)` ¶

Overview

Create a power loader.

Arguments: - base (:obj:Any): The base.

`msum(*items)` ¶

Overview

Create a sum loader.

Arguments: - items (:obj:tuple): The items.

`mmulti(*items)` ¶

Overview

Create a multi loader.

Arguments: - items (:obj:tuple): The items.

`mcmp(first, *items)` ¶

Overview

Create a multi compare loader.

Arguments: - first (:obj:Any): The first item. - items (:obj:tuple): The items.

Full Source Code

../ding/utils/loader/number.py

import mathimport operatorfrom typing import Optional, Union, Callable, Anyfrom .base import Loader, ILoaderClassfrom .utils import keep, check_onlyNUMBER_TYPES = (int, float)NUMBER_TYPING = Union[int, float]def numeric(int_ok: bool = True, float_ok: bool = True, inf_ok: bool = True) -> ILoaderClass:    """    Overview:        Create a numeric loader.    Arguments:        - int_ok (:obj:`bool`): Whether int is allowed.        - float_ok (:obj:`bool`): Whether float is allowed.        - inf_ok (:obj:`bool`): Whether inf is allowed.    """    if not int_ok and not float_ok:        raise ValueError('Either int or float should be allowed.')    def _load(value) -> NUMBER_TYPING:        if isinstance(value, NUMBER_TYPES):            if math.isnan(value):                raise ValueError('nan is not numeric value')            if isinstance(value, int) and not int_ok:                raise TypeError('int is not allowed but {actual} found'.format(actual=repr(value)))            if isinstance(value, float) and not float_ok:                raise TypeError('float is not allowed but {actual} found'.format(actual=repr(value)))            if math.isinf(value) and not inf_ok:                raise ValueError('inf is not allowed but {actual} found'.format(actual=repr(value)))            return value        else:            raise TypeError(                'numeric value should be either int, float or str, but {actual} found'.format(                    actual=repr(type(value).__name__)                )            )    return Loader(_load)def interval(        left: Optional[NUMBER_TYPING] = None,        right: Optional[NUMBER_TYPING] = None,        left_ok: bool = True,        right_ok: bool = True,        eps=0.0) -> ILoaderClass:    """    Overview:        Create a interval loader.    Arguments:        - left (:obj:`Optional[NUMBER_TYPING]`): The left bound.        - right (:obj:`Optional[NUMBER_TYPING]`): The right bound.        - left_ok (:obj:`bool`): Whether left bound is allowed.        - right_ok (:obj:`bool`): Whether right bound is allowed.        - eps (:obj:`float`): The epsilon.    """    if left is None:        left = -math.inf    if right is None:        right = +math.inf    if left > right:        raise ValueError(            "Left bound should no more than right bound, but {left} > {right}.".format(                left=repr(left), right=repr(right)            )        )    eps = math.fabs(eps)    def _value_compare_with_eps(a, b) -> int:        if math.fabs(a - b) <= eps:            return 0        elif a < b:            return -1        else:            return 1    def _load(value) -> NUMBER_TYPING:        _left_check = _value_compare_with_eps(value, left)        if _left_check < 0:            raise ValueError(                'value should be no less than {left} but {value} found'.format(left=repr(left), value=repr(value))            )        elif not left_ok and _left_check == 0:            raise ValueError(                'value should not be equal to left bound {left} but {value} found'.format(                    left=repr(left), value=repr(value)                )            )        _right_check = _value_compare_with_eps(value, right)        if _right_check > 0:            raise ValueError(                'value should be no more than {right} but {value} found'.format(right=repr(right), value=repr(value))            )        elif not right_ok and _right_check == 0:            raise ValueError(                'value should not be equal to right bound {right} but {value} found'.format(                    right=repr(right), value=repr(value)                )            )        return value    return Loader(_load)def is_negative() -> ILoaderClass:    """    Overview:        Create a negative loader.    """    return Loader((lambda x: x < 0, lambda x: ValueError('negative required but {value} found'.format(value=repr(x)))))def is_positive() -> ILoaderClass:    """    Overview:        Create a positive loader.    """    return Loader((lambda x: x > 0, lambda x: ValueError('positive required but {value} found'.format(value=repr(x)))))def non_negative() -> ILoaderClass:    """    Overview:        Create a non-negative loader.    """    return Loader(        (lambda x: x >= 0, lambda x: ValueError('non-negative required but {value} found'.format(value=repr(x))))    )def non_positive() -> ILoaderClass:    """    Overview:        Create a non-positive loader.    """    return Loader(        (lambda x: x <= 0, lambda x: ValueError('non-positive required but {value} found'.format(value=repr(x))))    )def negative() -> ILoaderClass:    """    Overview:        Create a negative loader.    """    return Loader(lambda x: -x)def positive() -> ILoaderClass:    """    Overview:        Create a positive loader.    """    return Loader(lambda x: +x)def _math_binary(func: Callable[[Any, Any], Any], attachment) -> ILoaderClass:    """    Overview:        Create a math binary loader.    Arguments:        - func (:obj:`Callable[[Any, Any], Any]`): The function.        - attachment (:obj:`Any`): The attachment.    """    return Loader(lambda x: func(x, Loader(attachment)(x)))def plus(addend) -> ILoaderClass:    """    Overview:        Create a plus loader.    Arguments:        - addend (:obj:`Any`): The addend.    """    return _math_binary(lambda x, y: x + y, addend)def minus(subtrahend) -> ILoaderClass:    """    Overview:        Create a minus loader.    Arguments:        - subtrahend (:obj:`Any`): The subtrahend.    """    return _math_binary(lambda x, y: x - y, subtrahend)def minus_with(minuend) -> ILoaderClass:    """    Overview:        Create a minus loader.    Arguments:        - minuend (:obj:`Any`): The minuend.    """    return _math_binary(lambda x, y: y - x, minuend)def multi(multiplier) -> ILoaderClass:    """    Overview:        Create a multi loader.    Arguments:        - multiplier (:obj:`Any`): The multiplier.    """    return _math_binary(lambda x, y: x * y, multiplier)def divide(divisor) -> ILoaderClass:    """    Overview:        Create a divide loader.    Arguments:        - divisor (:obj:`Any`): The divisor.    """    return _math_binary(lambda x, y: x / y, divisor)def divide_with(dividend) -> ILoaderClass:    """    Overview:        Create a divide loader.    Arguments:        - dividend (:obj:`Any`): The dividend.    """    return _math_binary(lambda x, y: y / x, dividend)def power(index) -> ILoaderClass:    """    Overview:        Create a power loader.    Arguments:        - index (:obj:`Any`): The index.    """    return _math_binary(lambda x, y: x ** y, index)def power_with(base) -> ILoaderClass:    """    Overview:        Create a power loader.    Arguments:        - base (:obj:`Any`): The base.    """    return _math_binary(lambda x, y: y ** x, base)def msum(*items) -> ILoaderClass:    """    Overview:        Create a sum loader.    Arguments:        - items (:obj:`tuple`): The items.    """    def _load(value):        return sum([item(value) for item in items])    return Loader(_load)def mmulti(*items) -> ILoaderClass:    """    Overview:        Create a multi loader.    Arguments:        - items (:obj:`tuple`): The items.    """    def _load(value):        _result = 1        for item in items:            _result *= item(value)        return _result    return Loader(_load)_COMPARE_OPERATORS = {    '!=': operator.__ne__,    '==': operator.__eq__,    '<': operator.__lt__,    '<=': operator.__le__,    '>': operator.__gt__,    '>=': operator.__ge__,}def _msinglecmp(first, op, second) -> ILoaderClass:    """    Overview:        Create a single compare loader.    Arguments:        - first (:obj:`Any`): The first item.        - op (:obj:`str`): The operator.        - second (:obj:`Any`): The second item.    """    first = Loader(first)    second = Loader(second)    if op in _COMPARE_OPERATORS.keys():        return Loader(            (                lambda x: _COMPARE_OPERATORS[op](first(x), second(x)), lambda x: ValueError(                    'comparison failed for {first} {op} {second}'.format(                        first=repr(first(x)),                        second=repr(second(x)),                        op=op,                    )                )            )        )    else:        raise KeyError('Invalid compare operator - {op}.'.format(op=repr(op)))def mcmp(first, *items) -> ILoaderClass:    """    Overview:        Create a multi compare loader.    Arguments:        - first (:obj:`Any`): The first item.        - items (:obj:`tuple`): The items.    """    if len(items) % 2 == 1:        raise ValueError('Count of items should be odd number but {number} found.'.format(number=len(items) + 1))    ops, items = items[0::2], items[1::2]    _result = keep()    for first, op, second in zip((first, ) + items[:-1], ops, items):        _result &= _msinglecmp(first, op, second)    return check_only(_result)

ding.utils.loader.number¶