jijmodeling 0.10.18__cp310-cp310-win_amd64.whl → 1.11.0__cp310-cp310-win_amd64.whl

jijmodeling/expression/variables/deci_vars.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-import warnings
-
-from typing import List, Optional, Tuple, Union
-
-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,
-    ):
-        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")
-        ```
-    """
-
-    def __init__(
-        self,
-        label: str,
-        shape=(),
-        uuid: Optional[str] = None,
-    ):
-        super().__init__(label, shape, uuid)
-
-
-class Integer(DecisionVariable):
-    """Integer decision variable."""
-
-    prefix = "_leint_"
-
-    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 lower(self):
-        return self._lower
-
-    @property
-    def upper(self):
-        return self._upper
-
-    def children(self) -> List[_expression.Expression]:
-        children = super().children() + [self.lower, self.upper]
-        return children
-
-
-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,73 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional, Tuple
-
-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.
-    """
-
-    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
-        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,107 +0,0 @@
-from __future__ import annotations
-
-import typing as tp
-
-from typeguard import check_type
-
-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", dim=2)
-        >>> d.dim
-        2
-        >>> k = jm.Placeholder("k", shape=(3, ))
-        >>> k.dim
-        1
-        ```
-    """
-
-    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)
-
-
-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", self._array, ArrayType)
-        check_type("self._dimension", self._dimension, int)
-
-        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)