jijmodeling 0.13.2__cp310-cp310-win_amd64.whl → 1.12.0__cp310-cp310-win_amd64.whl

jijmodeling/expression/utils.py

@@ -1,202 +0,0 @@
-from __future__ import annotations
-
-import itertools as it
-import typing as tp
-
-import typeguard as _typeguard
-
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.condition as _condition
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.extract as _extract
-import jijmodeling.expression.sum as _sum
-import jijmodeling.expression.variables.deci_vars as _deci_vars
-import jijmodeling.expression.variables.variable as _variable
-
-T = tp.TypeVar("T")
-
-
-def type_check_bool(value, cls) -> bool:
-    try:
-        _typeguard.check_type(value, cls)
-    # NOTE: typeguard >= 3.0.0 raises typeguard.TypeCheckError instead of TypeError
-    except _typeguard.TypeCheckError:
-        return False
-    else:
-        return True
-
-
-def extract_nodes(tree: _expression.Expression, cls: tp.Type[T]) -> tp.List[T]:
-    """
-    Extract specified class object from Expression tree.
-
-    Args:
-        tree (Expression): Target expression tree.
-        cls (Type): Target class.
-
-    Returns:
-        List: `cls` object list are included in `tree`.
-
-    Examples:
-        ```python
-        import jijmodeling as jm
-        d = jm.Placheolder("d", dim=1)
-        n = d.shape[0]
-        x = jm.Binary("x", shape=(n, ))
-        i = jm.Element("i", n)
-        term = jm.Sum(i, d[i]*x[i])
-        jm.extract_nodes(term, jm.DecisionVariable)
-        # [x]
-        ```
-    """
-    if type_check_bool(tree, cls):
-        nodes = [tree]
-    else:
-        nodes = []
-    for child in tree.children():
-        nodes = nodes + extract_nodes(child, cls)  # type: ignore
-    return nodes  # type: ignore
-
-
-def get_order(expression: _expression.Expression) -> int:
-    """
-    Get an order of polynomial.
-
-    For example, x_i * y_i + x_i -> 2 if x and y is a decision variable.
-
-    Args:
-        expression (Expression): expression
-
-    Returns:
-        int: Integer
-    """
-    if isinstance(expression, _deci_vars.DecisionVariable):
-        return 1
-    if isinstance(expression, _variable.Subscripts):
-        if isinstance(expression.variable, _deci_vars.DecisionVariable):
-            return 1
-        else:
-            return 0
-    if isinstance(expression, (_expression.Add, _expression.Div)):
-        child_order = [get_order(child) for child in expression.children()]
-        return max(child_order)
-    if isinstance(expression, _expression.Mul):
-        child_order = [get_order(child) for child in expression.children()]
-        return sum(child_order)
-    if isinstance(expression, _expression.Power):
-        base_order = get_order(expression.left)
-        if base_order > 0:
-            if isinstance(expression.right, _expression.Number):
-                return base_order * int(expression.right.value)
-            else:
-                raise _exceptions.ModelingError("exponent should be number.")
-    if isinstance(expression, _sum.SumOperator):
-        return get_order(expression.operand)
-    else:
-        return 0
-
-
-def expression_indices(
-    expression: _expression.Expression,
-) -> tp.List[_variable.Element]:
-    """
-    Extract all indices from the expression.
-
-    Args:
-        expression (Expression): expression
-
-    Returns:
-        List[Element]:
-    """
-    # TODO: implement expression_indices for each expression?
-    indices: tp.List[_variable.Element]
-    if isinstance(expression, _variable.Element):
-        set_indices: tp.List[_variable.Element] = []
-        for child in expression.children():
-            set_indices = set_indices + expression_indices(child)
-        indices = [expression] + set_indices
-    elif isinstance(expression, _expression.Number):
-        indices = []
-    elif isinstance(expression, _variable.Variable):
-        indices = []
-    elif isinstance(expression, _variable.Subscripts):
-        indices = []
-        for subs in expression.subscripts:
-            indices = indices + expression_indices(subs)
-    elif isinstance(expression, _expression.Expression):
-        indices = []
-        for child in expression.children():
-            if child is not None:
-                indices = indices + expression_indices(child)
-    else:
-        raise TypeError(f"expression is Expression, not {type(expression)}")
-
-    # check duplicated element
-    el_label = []
-    if isinstance(expression, _sum.ReductionOperator):
-        el_label = [expression.sum_index.label]
-
-    unique_indices: tp.List[_variable.Element] = []
-    for index in indices:
-        if index.label not in el_label:
-            el_label.append(index.label)
-            unique_indices.append(index)
-    return unique_indices
-
-
-def condition_indices(condition: _condition.Condition) -> tp.List[_variable.Element]:
-    if isinstance(condition, _condition.CompareCondition):
-        left_indices = expression_indices(condition.left)
-        right_indices = expression_indices(condition.right)
-        return left_indices + right_indices
-    elif isinstance(condition, _condition.ConditionOperator):
-        left_indices = condition_indices(condition.left)
-        right_indices = condition_indices(condition.right)
-        return left_indices + right_indices
-    else:
-        return []
-
-
-def check_non_decision_variable(
-    exp_list: tp.Iterable[_expression.Expression], error_msg: str
-):
-    """
-    Check if list has decision variable or not.
-
-    Args:
-        exp_list (Iterable[Expression]): target iterator.
-        error_msg (str): error message.
-
-    Raises:
-        CannotContainDecisionVarError: if list has decision variable.
-    """
-    for e in exp_list:
-        variables = _extract.extract_variables(e)
-        for v in variables:
-            if isinstance(v, _deci_vars.DecisionVariable):
-                raise _exceptions.CannotContainDecisionVarError(error_msg)
-
-
-def flatten_binary_operator(
-    expression: _expression.Expression,
-    op_type: tp.Type[_expression.BinaryOperator] = _expression.Add,
-) -> tp.List[_expression.Expression]:
-    """
-    Flatten `op_type` binary operator to list.
-    This function flattens a given node to the following:
-        node1 <> node2 <> node3 <> ... <> nodeN -> [node1, node2, node3, ..., nodeN]
-    where <> is a specified binary operator by `op_type`.
-
-    Args:
-        expression (Expression): target expression.
-        op_type (Type[BinaryOperator]): target binary operator.
-
-    Returns:
-        List[Expression]: list of expression. Each element is not binary operator.
-    """
-    if isinstance(expression, op_type):
-        left = flatten_binary_operator(expression.left, op_type)
-        right = flatten_binary_operator(expression.right, op_type)
-        return list(it.chain.from_iterable([left, right]))
-    else:
-        return [expression]

jijmodeling/expression/variables/__init__.py

@@ -1,39 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.expression.variables.deci_vars as deci_vars
-import jijmodeling.expression.variables.jagged_array as jagged_array
-import jijmodeling.expression.variables.placeholders as placeholders
-import jijmodeling.expression.variables.variable as variable
-
-from jijmodeling.expression.variables.deci_vars import (
-    Binary,
-    BinaryVar,
-    DecisionVariable,
-    Integer,
-    IntegerVar,
-    LogEncInteger,
-)
-from jijmodeling.expression.variables.jagged_array import JaggedArray
-from jijmodeling.expression.variables.placeholders import ArrayShape, Placeholder
-from jijmodeling.expression.variables.variable import Element, Subscripts, Variable
-
-__all__ = [
-    "deci_vars",
-    "jagged_array",
-    "placeholders",
-    "variable",
-    "Variable",
-    "Subscripts",
-    "Element",
-    "Placeholder",
-    "ArrayShape",
-    "JaggedArray",
-    "DecisionVariable",
-    "Binary",
-    "BinaryVar",
-    "LogEncInteger",
-    "Integer",
-    "IntegerVar",
-]

jijmodeling/expression/variables/deci_vars.py

@@ -1,212 +0,0 @@
-from __future__ import annotations
-
-import warnings
-
-from typing import List, Optional, Tuple, Union
-
-from jijmodeling.deprecation.deprecation import (
-    deprecated_kwargs, 
-    deprecated_name,
-    JijFutureWarning
-)
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.type_annotations as _type_annotations
-import jijmodeling.expression.variables.variable as _variable
-
-
-class DecisionVariable(_variable.Variable):
-    def __init__(
-        self,
-        label: str,
-        shape: Union[
-            List[_type_annotations.ShapeElemInputType],
-            Tuple[_type_annotations.ShapeElemInputType, ...],
-            _type_annotations.ShapeElemInputType,
-        ],
-        uuid: Optional[str] = None,
-    ):
-        if "[" in label or "]" in label:
-            raise _exceptions.ModelingError(
-                "The label of decision variable cannot contain '[' or ']'."
-            )
-        super().__init__(label, shape, uuid)  # type: ignore
-
-
-class Binary(DecisionVariable):
-    """Binary decision variable 0 or 1.
-
-    Example:
-        ```python
-        import jijmodeling as jm
-        n = jm.Placeholder("n")
-        x = jm.Binary("x", shape=(n,))
-        # scalar variable
-        y = jm.Binary("y")
-        ```
-    """
-
-    @deprecated_name("Binary", "BinaryVar", kind="class")
-    def __init__(
-        self,
-        label: str,
-        shape=(),
-        uuid: Optional[str] = None,
-    ):
-        super().__init__(label, shape, uuid)
-
-    @property
-    def label(self) -> str:
-        return self._label
-    
-    @property
-    def dim(self) -> int:
-        return len(self.shape)
-
-
-@deprecated_kwargs(removes=["uuid"])
-def BinaryVar(
-    name: str,
-    *,
-    shape=(),
-    uuid: Optional[str] = None,
-) -> Binary:
-    """Binary decision variable 0 or 1.
-
-    Example:
-        ```python
-        import jijmodeling as jm
-        n = jm.Placeholder("n")
-        x = jm.BinaryVar("x", shape=(n,))
-        # scalar variable
-        y = jm.BinaryVar("y")
-        ```
-    """
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=JijFutureWarning)
-        return Binary(name, shape, uuid)
-
-
-class Integer(DecisionVariable):
-    """Integer decision variable."""
-
-    prefix = "_leint_"
-
-    @deprecated_name("Integer", "IntegerVar", kind="class")
-    def __init__(
-        self,
-        label: str,
-        lower: Union[_expression.Expression, int, float],
-        upper: Union[_expression.Expression, int, float],
-        shape: Union[
-            List[_type_annotations.ShapeElemInputType],
-            Tuple[_type_annotations.ShapeElemInputType, ...],
-            _type_annotations.ShapeElemInputType,
-        ] = (),
-        uuid: Optional[str] = None,
-    ):
-        super().__init__(label, shape, uuid)
-
-        if isinstance(lower, (int, float)):
-            self._lower: _expression.Expression = _expression.Number(lower)
-        else:
-            self._lower = lower
-        if isinstance(upper, (int, float)):
-            self._upper: _expression.Expression = _expression.Number(upper)
-        else:
-            self._upper = upper
-
-        # check if self._lower is operatable or self._lower.shape equals to
-        # self.shape
-        from jijmodeling.match.expr_same import expr_same
-
-        def has_equal_shape(shape1, shape2):
-            if len(shape1) != len(shape2):
-                return False
-            else:
-                return all(
-                    map(
-                        lambda x: expr_same(x[0], x[1], check_id=False),
-                        zip(list(shape1), list(shape2)),
-                    )
-                )
-
-        if not (
-            self._lower.is_operatable()
-            or has_equal_shape(self._lower.shape, self.shape)
-        ):  # type: ignore
-            raise _exceptions.ModelingError(
-                "self._lower must be operatable or self._lower.shape must be equal to self.shape"
-            )
-
-        if not (
-            self._upper.is_operatable()
-            or has_equal_shape(self._upper.shape, self.shape)
-        ):  # type: ignore
-            raise _exceptions.ModelingError(
-                "self._upper must be operatable or self._upper.shape must be equal to self.shape"
-            )
-
-        import jijmodeling.expression.utils as _utils
-
-        _utils.check_non_decision_variable(
-            [self.lower, self.upper],
-            f"The lower and upper of '{self.label}' cannot contain decision variable.",
-        )
-
-    @property
-    def label(self) -> str:
-        return self._label
-    
-    @property
-    def dim(self) -> int:
-        return super().dim
-
-    @property
-    def lower(self) -> _expression.Expression:
-        return self._lower
-    
-    @property
-    def lower_bound(self) -> _expression.Expression:
-        return self._lower
-
-    @property
-    def upper(self):
-        return self._upper
-    
-    @property
-    def upper_bound(self) -> _expression.Expression:
-        return self._upper
-
-    def children(self) -> List[_expression.Expression]:
-        children = super().children() + [self.lower, self.upper]
-        return children
-
-
-@deprecated_kwargs(removes=["uuid"])
-def IntegerVar(
-    name: str,
-    *,
-    lower_bound: Union[_expression.Expression, int, float],
-    upper_bound: Union[_expression.Expression, int, float],
-    shape: Union[
-        List[_type_annotations.ShapeElemInputType],
-        Tuple[_type_annotations.ShapeElemInputType, ...],
-        _type_annotations.ShapeElemInputType,
-    ] = (),
-    uuid: Optional[str] = None,
-) -> Integer:
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=JijFutureWarning)
-        return Integer(name, lower_bound, upper_bound, shape, uuid)
-
-
-def LogEncInteger(*args, **kwargs) -> Integer:
-    """
-    This constructor method is deprecated.
-
-    Returns:
-        Integer: Integer object.
-    """
-    warnings.warn("LogEncInteger is deprecated. Please use jijmodeling.Integer.")
-    return Integer(*args, **kwargs)

jijmodeling/expression/variables/jagged_array.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional, Tuple
-import warnings
-
-from jijmodeling.deprecation.deprecation import (
-    deprecated_name,
-    JijFutureWarning
-)
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.type_annotations as _type_annotations
-import jijmodeling.expression.variables.placeholders as _placeholders
-
-
-class JaggedArray(_placeholders.Placeholder):
-    """
-    Jagged array: A data structure in which each element in a two-dimensional.
-
-    array has a different length in a one-dimensional array. The internal
-    length of the data is different, so `shape` is not defined. Only `shape[0]`
-    can be accessed directly in `.shape`.
-
-    A jagged array is an array with the following data structure, for example
-
-    ```python
-    [[1, 2, 3],
-     [3, 2, 4, 5],
-     [0, 1]]
-    ```
-
-    The Placeholder class can handle multi-dimensional arrays that can be defined with shape, but it cannot handle a jagged arrays.
-    Therefore, we need to use this class instead.
-    """
-
-    @deprecated_name("JaggedArray", kind="class")
-    def __init__(
-        self,
-        label: str,
-        dim: int,
-        uuid: Optional[str] = None,
-    ):
-        """
-        Args:
-            label (str): label of variable
-            dim (int): dimension of jagged array. Because of the jagged array data structure, `shape` cannot be specified in the constructor.
-            uuid (Optional[str], optional): uuid. Defaults to None.
-
-        Raises:
-            ModelingError: The jagged array can currently only handle up to two dimensions. This limitation will be resolved in an update.
-        """
-
-        if dim > 5:
-            raise _exceptions.ModelingError(
-                "JaggedArray must be set to 5-dim or less, not {}.".format(dim)
-            )
-
-        self._dim = dim
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=JijFutureWarning)
-            super().__init__(label, dim, uuid=uuid)
-
-    @property
-    def dim(self) -> int:
-        return self._dim
-
-    @property
-    def shape(self) -> Tuple[_type_annotations.ShapeElementType]:
-        """
-        Shape cannot be defined in the jagged array.
-
-        Only the length can be
-        defined, so only the `.shape[0]` corresponding to the length is returned.
-
-        Returns:
-            Tuple[Expression]: (length, )
-        """
-        return (super().shape[0],)
-
-    @property
-    def length(self) -> _type_annotations.ShapeElementType:
-        return self.shape[0]

jijmodeling/expression/variables/placeholders.py

@@ -1,132 +0,0 @@
-from __future__ import annotations
-
-import typing as tp
-import warnings
-
-from typeguard import check_type
-
-from jijmodeling.deprecation.deprecation import (
-    deprecated_kwargs,
-    JijFutureWarning
-)
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.variables.variable as _variable
-
-
-class Placeholder(_variable.Variable):
-    """
-    Placeholder variable.
-
-    Variables for pouring in data when converting to QUBO or to MIP.
-    When using the Placeholder class,
-    you can specify the specific value to be placed in the Placeholder
-    by using the `ph_value` argument of methods such as `.to_pyqubo` and `.to_lp` of the Problem class.
-    If you want to handle array data that cannot be defined with shape (called jagged array), you can use the `JaggedArray` class.
-
-    Example:
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder("d", ndim=2)
-        d.ndim
-        # 2
-        ```
-    """
-    @tp.overload
-    def __init__(
-        self,
-        name: str,
-        *,
-        ndim: tp.Optional[int] = None,
-    ): ...
-
-    @deprecated_kwargs(
-        name="Placeholder",
-        pos_len=1,
-        changes={"label":"name", "dim":"ndim"},
-        removes=["shape", "uuid"],
-    )
-    def __init__(
-        self,
-        label: str,
-        dim: tp.Optional[int] = None,
-        shape=None,
-        uuid: tp.Optional[str] = None,
-    ):
-        if shape is not None:
-            _shape = shape
-        elif shape is None and dim is not None:
-            _shape = tuple(None for _ in range(dim))
-        else:
-            _shape = []
-        super().__init__(label, shape=_shape, uuid=uuid)
-
-    @property
-    def label(self) -> str:
-        return self._label
-    
-    @property
-    def dim(self) -> int:
-        return len(self.shape)
-
-
-class ArrayShape(Placeholder):
-    """
-    Shape of variable.
-
-    Example:
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder("d", dim=1)
-        n = d.shape[0]
-        print(type(n))
-        # <class 'ArrayShape'>
-        ```
-    """
-
-    def __init__(
-        self,
-        array: tp.Union[_variable.Variable, _variable.Subscripts],
-        dimension: int,
-        uuid: tp.Optional[str] = None,
-    ):
-        """
-        Basically, a user does not call the constuctor directly; an object of.
-
-        this class is created instead when shape value of a variable is None.
-
-        Args:
-            array (Variable): parent array
-            dimension (int): dimension is corresponded this object.
-        """
-        self._array = array
-        self._dimension = dimension
-
-        # type and value validation
-        ArrayType = tp.Union[_variable.Variable, _variable.Subscripts]
-        check_type(self._array, ArrayType)
-        check_type(self._dimension, int)
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=JijFutureWarning)
-            super().__init__(str(self._array) + "_shape_%d" % dimension, uuid=uuid)
-
-    @property
-    def array(self):
-        return self._array
-
-    @property
-    def array_dim(self):
-        return self.array.dim
-
-    @property
-    def dimension(self):
-        return self._dimension
-
-    def is_operatable(self) -> bool:
-        return True
-
-    def children(self) -> tp.List[_expression.Expression]:
-        return [self.array]
-
-    def __hash__(self) -> int:
-        return hash(self.label)